#include "ThreadPool.h"
#include "api.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

#define NUMBER 2
#define QUEUE_MAX 1024 * 1024 / 4

void taskFunc(void *arg)
{
    RLEencode_task *task = (RLEencode_task *)arg;
    // printf("thread %ld is working...\n", pthread_self());
    task->encodeed_data_len = RLEencode(task->raw_data, task->raw_data_len, task->encodeed_data);
    task->isFinished = 1;
    // sleep(1);
}

void multi_file_multi_thread_RLEencode(int file_cnt, char **file_path, int thread_cnt)
{
    // 创建线程池
    ThreadPool *pool = (ThreadPool *)malloc(sizeof(ThreadPool));
    if (pool == NULL)
    {
        printf("malloc threadpool fail...\n");
        return;
    }

    pool->threadIDs = (pthread_t *)malloc(sizeof(pthread_t) * thread_cnt);
    if (pool->threadIDs == NULL)
    {
        printf("malloc threadIDs fail...\n");
        return;
    }
    memset(pool->threadIDs, 0, sizeof(pthread_t) * thread_cnt);
    pool->minNum = thread_cnt;
    pool->maxNum = thread_cnt;
    pool->busyNum = 0;
    pool->liveNum = thread_cnt;
    pool->exitNum = 0;

    if (pthread_mutex_init(&pool->mutexPool, NULL) != 0 ||
        pthread_mutex_init(&pool->mutexBusy, NULL) != 0 ||
        pthread_cond_init(&pool->notEmpty, NULL) != 0 ||
        pthread_cond_init(&pool->notFull, NULL) != 0)
    {
        printf("mutex or condition init fail...\n");
        return;
    }

    pool->taskQ = (Task *)malloc(sizeof(Task) * QUEUE_MAX);
    pool->queueCapacity = QUEUE_MAX;
    pool->queueSize = 0;
    pool->queueFront = 0;
    pool->queueRear = 0;

    pool->shutdown = 0;

    RLEencode_task **task = (RLEencode_task **)malloc(sizeof(RLEencode_task *) * QUEUE_MAX);
    int task_cnt = 0;
    for (int i = 0; i < file_cnt; ++i)
    {
        int fd = -1, f_len = 0;
        char *mmap_ptr;
        struct stat file_stat;

        fd = open(file_path[i], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
        if (fd == -1)
        {
            printf("Open file failed: %s\n", strerror(errno));
            return;
        }
        if (fstat(fd, &file_stat) == -1)
        {
            printf("Get file stat failed: %s\n", strerror(errno));
            close(fd);
            return;
        }
        f_len = file_stat.st_size;
        if (f_len == 0)
        {
            close(fd);
            return;
        }

        // printf("len = %d\n", f_len);

        mmap_ptr = (char*)mmap(0, f_len, PROT_READ, MAP_SHARED, fd, 0);
        if (mmap_ptr == (void *)-1)
        {
            printf("mmap failed: %s\n", strerror(errno));
            return;
        }
        close(fd);

        // printf("%s\n", (char*)mmap_ptr);

        int remain_len = f_len, curblock_cnt = 0;
        while (remain_len >= 4096)
        {
            task[task_cnt] = (RLEencode_task *)malloc(sizeof(RLEencode_task));
            task[task_cnt]->isFinished = 0;
            task[task_cnt]->raw_data = (char *)(mmap_ptr + 4096 * curblock_cnt);
            task[task_cnt]->raw_data_len = 4096;
            task[task_cnt]->encodeed_data = (char *)malloc(sizeof(char) * 8192);
            memset(task[task_cnt]->encodeed_data, 0, sizeof(char) * 8192);
            task[task_cnt]->encodeed_data_len = 0;

            // threadPoolAdd(pool, taskFunc, task[task_cnt]);
            pool->taskQ[pool->queueRear].function = taskFunc;
            pool->taskQ[pool->queueRear].arg = task[task_cnt];
            pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
            pool->queueSize++;

            ++curblock_cnt;
            ++task_cnt;
            remain_len -= 4096;
        }
        if (remain_len > 0)
        {
            task[task_cnt] = (RLEencode_task *)malloc(sizeof(RLEencode_task));
            task[task_cnt]->isFinished = 0;
            task[task_cnt]->raw_data = (char *)(mmap_ptr + 4096 * curblock_cnt);
            task[task_cnt]->raw_data_len = remain_len;
            task[task_cnt]->encodeed_data = (char *)malloc(sizeof(char) * remain_len * 2);
            memset(task[task_cnt]->encodeed_data, 0, sizeof(char) * remain_len * 2);
            task[task_cnt]->encodeed_data_len = 0;

            // threadPoolAdd(pool, taskFunc, task[task_cnt]);
            pool->taskQ[pool->queueRear].function = taskFunc;
            pool->taskQ[pool->queueRear].arg = task[task_cnt];
            pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
            pool->queueSize++;

            ++curblock_cnt;
            ++task_cnt;
            remain_len = 0;
        }
    }

    for (int i = 0; i < thread_cnt; ++i)
    {
        pthread_create(&pool->threadIDs[i], NULL, worker, pool);
    }

    for (int i = 0; i < thread_cnt; ++i)
    {
        pthread_join(pool->threadIDs[i], NULL);
    }

    int finished_cnt = 1;
    RLEencode_task *pre = task[0], *p = task[1];
    while (finished_cnt < task_cnt)
    {

        // printf("2");
        if (pre->encodeed_data[pre->encodeed_data_len - 2] == p->encodeed_data[0])
        {
            p->encodeed_data[1] += pre->encodeed_data[pre->encodeed_data_len - 1];
            pre->encodeed_data[pre->encodeed_data_len - 2] = 0;
            pre->encodeed_data[pre->encodeed_data_len - 1] = 0;
            printf("%s", pre->encodeed_data);
            munmap(pre->raw_data, pre->raw_data_len);
            free(pre->encodeed_data);
            free(pre);
        }
        else
        {
            printf("%s", pre->encodeed_data);
            munmap(pre->raw_data, pre->raw_data_len);
            free(pre->encodeed_data);
            free(pre);
        }
        ++finished_cnt;
        pre = p;
        p = task[finished_cnt];
    }
    printf("%s", pre->encodeed_data);
    munmap(pre->raw_data, pre->raw_data_len);
    free(pre->encodeed_data);
    free(pre);
    threadPoolDestroy(pool);
}

// ThreadPool *threadPoolCreate(int min, int max, int queueSize)
// {
//     ThreadPool *pool = (ThreadPool *)malloc(sizeof(ThreadPool));
//     do
//     {
//         if (pool == NULL)
//         {
//             printf("malloc threadpool fail...\n");
//             break;
//         }

//         pool->threadIDs = (pthread_t *)malloc(sizeof(pthread_t) * max);
//         if (pool->threadIDs == NULL)
//         {
//             printf("malloc threadIDs fail...\n");
//             break;
//         }
//         memset(pool->threadIDs, 0, sizeof(pthread_t) * max);
//         pool->minNum = min;
//         pool->maxNum = max;
//         pool->busyNum = 0;
//         pool->liveNum = min; // 和最小个数相等
//         pool->exitNum = 0;

//         if (pthread_mutex_init(&pool->mutexPool, NULL) != 0 ||
//             pthread_mutex_init(&pool->mutexBusy, NULL) != 0 ||
//             pthread_cond_init(&pool->notEmpty, NULL) != 0 ||
//             pthread_cond_init(&pool->notFull, NULL) != 0)
//         {
//             printf("mutex or condition init fail...\n");
//             break;
//         }

//         // 任务队列
//         pool->taskQ = (Task *)malloc(sizeof(Task) * queueSize);
//         pool->queueCapacity = queueSize;
//         pool->queueSize = 0;
//         pool->queueFront = 0;
//         pool->queueRear = 0;

//         pool->shutdown = 0;

//         // 创建线程
//         pthread_create(&pool->managerID, NULL, manager, pool);
//         for (int i = 0; i < min; ++i)
//         {
//             pthread_create(&pool->threadIDs[i], NULL, worker, pool);
//         }
//         return pool;
//     } while (0);

//     // 释放资源
//     if (pool && pool->threadIDs)
//         free(pool->threadIDs);
//     if (pool && pool->taskQ)
//         free(pool->taskQ);
//     if (pool)
//         free(pool);

//     return NULL;
// }

int threadPoolDestroy(ThreadPool *pool)
{
    if (pool == NULL)
    {
        return -1;
    }

    // 关闭线程池
    pool->shutdown = 1;
    // 阻塞回收管理者线程
    // pthread_join(pool->managerID, NULL);
    // 唤醒阻塞的消费者线程
    // for (int i = 0; i < pool->liveNum; ++i)
    // {
    //     pthread_cond_signal(&pool->notEmpty);
    // }
    // 释放堆内存
    if (pool->taskQ)
    {
        free(pool->taskQ);
    }
    if (pool->threadIDs)
    {
        free(pool->threadIDs);
    }

    pthread_mutex_destroy(&pool->mutexPool);
    pthread_mutex_destroy(&pool->mutexBusy);
    pthread_cond_destroy(&pool->notEmpty);
    pthread_cond_destroy(&pool->notFull);

    free(pool);
    pool = NULL;

    return 0;
}

// void threadPoolAdd(ThreadPool *pool, void (*func)(void *), void *arg)
// {
//     pthread_mutex_lock(&pool->mutexPool);
//     while (pool->queueSize == pool->queueCapacity && !pool->shutdown)
//     {
//         // 阻塞生产者线程
//         pthread_cond_wait(&pool->notFull, &pool->mutexPool);
//     }
//     if (pool->shutdown)
//     {
//         pthread_mutex_unlock(&pool->mutexPool);
//         return;
//     }
//     // 添加任务
//     pool->taskQ[pool->queueRear].function = func;
//     pool->taskQ[pool->queueRear].arg = arg;
//     pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
//     pool->queueSize++;

//     pthread_cond_signal(&pool->notEmpty);
//     pthread_mutex_unlock(&pool->mutexPool);
// }

// int threadPoolBusyNum(ThreadPool *pool)
// {
//     pthread_mutex_lock(&pool->mutexBusy);
//     int busyNum = pool->busyNum;
//     pthread_mutex_unlock(&pool->mutexBusy);
//     return busyNum;
// }

// int threadPoolAliveNum(ThreadPool *pool)
// {
//     pthread_mutex_lock(&pool->mutexPool);
//     int aliveNum = pool->liveNum;
//     pthread_mutex_unlock(&pool->mutexPool);
//     return aliveNum;
// }

void *worker(void *arg)
{
    ThreadPool *pool = (ThreadPool *)arg;

    while (1)
    {
        pthread_mutex_lock(&pool->mutexPool);
        // 当前任务队列是否为空
        // while (pool->queueSize == 0 && !pool->shutdown)
        // {
        //     // 阻塞工作线程
        //     pthread_cond_wait(&pool->notEmpty, &pool->mutexPool);

        //     // 判断是不是要销毁线程
        //     if (pool->exitNum > 0)
        //     {
        //         pool->exitNum--;
        //         if (pool->liveNum > pool->minNum)
        //         {
        //             pool->liveNum--;
        //             pthread_mutex_unlock(&pool->mutexPool);
        //             threadExit(pool);
        //         }
        //     }
        // }

        if (pool->queueSize == 0){
            pthread_mutex_unlock(&pool->mutexPool);
            pthread_exit(NULL);
        }

        // 判断线程池是否被关闭了
        // if (pool->shutdown)
        // {
        //     pthread_mutex_unlock(&pool->mutexPool);
        //     threadExit(pool);
        // }

        // 从任务队列中取出一个任务
        Task task;
        task.function = pool->taskQ[pool->queueFront].function;
        task.arg = pool->taskQ[pool->queueFront].arg;
        // 移动头结点
        pool->queueFront = (pool->queueFront + 1) % pool->queueCapacity;
        pool->queueSize--;
        // 解锁
        // pthread_cond_signal(&pool->notFull);
        pthread_mutex_unlock(&pool->mutexPool);

        // printf("thread %ld start working...\n", pthread_self());
        // pthread_mutex_lock(&pool->mutexBusy);
        // pool->busyNum++;
        // pthread_mutex_unlock(&pool->mutexBusy);
        task.function(task.arg);
        // free(task.arg);
        // task.arg = NULL;

        // printf("thread %ld end working...\n", pthread_self());
        // pthread_mutex_lock(&pool->mutexBusy);
        // pool->busyNum--;
        // pthread_mutex_unlock(&pool->mutexBusy);
    }
    return NULL;
}

// void *manager(void *arg)
// {
//     ThreadPool *pool = (ThreadPool *)arg;
//     while (!pool->shutdown)
//     {
//         // 每隔3s检测一次
//         sleep(3);

//         // 取出线程池中任务的数量和当前线程的数量
//         pthread_mutex_lock(&pool->mutexPool);
//         int queueSize = pool->queueSize;
//         int liveNum = pool->liveNum;
//         pthread_mutex_unlock(&pool->mutexPool);

//         // 取出忙的线程的数量
//         pthread_mutex_lock(&pool->mutexBusy);
//         int busyNum = pool->busyNum;
//         pthread_mutex_unlock(&pool->mutexBusy);

//         // 添加线程
//         // 任务的个数>存活的线程个数 && 存活的线程数<最大线程数
//         if (queueSize > liveNum && liveNum < pool->maxNum)
//         {
//             pthread_mutex_lock(&pool->mutexPool);
//             int counter = 0;
//             for (int i = 0; i < pool->maxNum && counter < NUMBER && pool->liveNum < pool->maxNum; ++i)
//             {
//                 if (pool->threadIDs[i] == 0)
//                 {
//                     pthread_create(&pool->threadIDs[i], NULL, worker, pool);
//                     counter++;
//                     pool->liveNum++;
//                 }
//             }
//             pthread_mutex_unlock(&pool->mutexPool);
//         }
//         // 销毁线程
//         // 忙的线程*2 < 存活的线程数 && 存活的线程>最小线程数
//         if (busyNum * 2 < liveNum && liveNum > pool->minNum)
//         {
//             pthread_mutex_lock(&pool->mutexPool);
//             pool->exitNum = NUMBER;
//             pthread_mutex_unlock(&pool->mutexPool);
//             // 让工作的线程自杀
//             for (int i = 0; i < NUMBER; ++i)
//             {
//                 pthread_cond_signal(&pool->notEmpty);
//             }
//         }
//     }
//     return NULL;
// }

// void threadExit(ThreadPool *pool)
// {
//     pthread_t tid = pthread_self();
//     for (int i = 0; i < pool->maxNum; ++i)
//     {
//         if (pool->threadIDs[i] == tid)
//         {
//             pool->threadIDs[i] = 0;
//             // printf("threadExit() called, %ld exiting...\n", tid);
//             break;
//         }
//     }
//     pthread_exit(NULL);
// }
